#[cfg(test)]
mod test {


    /*
        当你将 Vec<T> 作为参数传递时，所有权会转移到函数中。
        这意味着调用函数后，原始的 Vec<T> 将不再有效。
     */
    fn sum1(args : Vec<i32>) -> i32{
        args.iter().sum()
    }
    /*
        当你将 &Vec<T> 作为参数传递时，只传递了引用，
        所有权仍然在调用者手中。这意味着调用函数后，
        原始的 Vec<T> 仍然有效。
     */
    fn sum2(vec: &Vec<i32>) -> i32 {
        vec.iter().sum()
    }
    /*
        在 Rust 中，更常见的做法是传递切片（&[T]），
        而不是 &Vec<T>。切片是对 Vec<T> 或其他连续内存区域的引用，
        更加通用和灵活。
     */

     fn sum3(slice: &[i32]) -> i32 {
        slice.iter().sum()
    }
    #[test]
    fn main() {
        /* type 1 start */
        let arr1 = vec![1,2,3,4];
        let result1 = sum1(arr1);
        println!("Sum1:{}",result1);
        // println!("arr:{}",arr); arr作为参数传递时， 失效。
        /* type 1 end */

        /* type 2 start */
        let arr2 = vec![1, 2, 3, 4];
        let result2 = sum2(&arr2); // 传递引用
        println!("Sum: {}", result2);
        // arr2 仍然有效
        println!("{:?}", arr2); // 输出: [1, 2, 3, 4]
        /* type 2 end */

        /* type 3 start */
        let arr3 = vec![1, 2, 3, 4];
        let result3 = sum3(&arr3); // 传递引用
        println!("Sum: {}", result3);
        // arr2 仍然有效
        println!("{:?}", arr3); // 输出: [1, 2, 3, 4]
        /* type 3 end */
    }
}